//! 查询优化器简单测试
//! 
//! 独立测试查询优化器的核心功能

use super::optimizer::*;
use crate::sql::Value;
use std::sync::Arc;

/// 简单的优化器测试
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_statistics_collector_basic() {
        println!("🧪 测试统计信息收集器基础功能...");
        
        let collector = StatisticsCollector::new();
        
        // 测试表统计信息收集
        let test_data = vec![
            vec![Value::Integer(1), Value::Text("Alice".to_string())],
            vec![Value::Integer(2), Value::Text("Bob".to_string())],
            vec![Value::Integer(3), Value::Text("Charlie".to_string())],
        ];
        
        let result = collector.collect_table_statistics("test_table", &test_data);
        assert!(result.is_ok());
        
        // 验证统计信息
        let stats = collector.get_table_statistics("test_table");
        assert!(stats.is_some());
        
        let table_stats = stats.unwrap();
        assert_eq!(table_stats.row_count, 3);
        assert!(table_stats.avg_row_size > 0.0);
        
        println!("  表行数: {}", table_stats.row_count);
        println!("  平均行大小: {:.2} 字节", table_stats.avg_row_size);
        
        println!("✅ 统计信息收集器基础功能测试通过");
    }

    #[test]
    fn test_cost_model_basic() {
        println!("🧪 测试成本模型基础功能...");
        
        let statistics_collector = Arc::new(StatisticsCollector::new());
        let mut cost_model = CostModel::new(statistics_collector.clone());
        
        // 测试成本参数
        let params = cost_model.get_parameters();
        assert!(params.seq_scan_cost_per_row > 0.0);
        assert!(params.index_scan_cost_per_row > 0.0);
        assert!(params.cpu_cost_per_row > 0.0);
        
        println!("  顺序扫描成本: {:.4}", params.seq_scan_cost_per_row);
        println!("  索引扫描成本: {:.4}", params.index_scan_cost_per_row);
        println!("  CPU处理成本: {:.4}", params.cpu_cost_per_row);
        
        // 测试参数更新
        let new_params = CostParameters {
            seq_scan_cost_per_row: 2.0,
            index_scan_cost_per_row: 0.2,
            random_page_cost: 8.0,
            sequential_page_cost: 2.0,
            cpu_cost_per_row: 0.02,
            memory_cost_per_byte: 0.000002,
            join_base_cost: 20.0,
            sort_base_cost: 10.0,
        };
        
        cost_model.update_parameters(new_params.clone());
        
        let updated_params = cost_model.get_parameters();
        assert_eq!(updated_params.seq_scan_cost_per_row, 2.0);
        assert_eq!(updated_params.join_base_cost, 20.0);
        
        println!("  更新后顺序扫描成本: {:.4}", updated_params.seq_scan_cost_per_row);
        
        println!("✅ 成本模型基础功能测试通过");
    }

    #[test]
    fn test_plan_cache_basic() {
        println!("🧪 测试计划缓存基础功能...");
        
        let plan_cache = PlanCache::new();
        
        let query_hash = "test_query_hash".to_string();
        
        // 测试缓存未命中
        assert!(plan_cache.get(&query_hash).is_none());
        
        // 测试缓存统计信息
        let stats = plan_cache.get_stats();
        assert_eq!(stats.misses, 1);
        
        // 测试缓存配置
        let hit_rate = plan_cache.hit_rate();
        assert_eq!(hit_rate, 0.0); // 没有命中
        
        println!("  初始命中率: {:.2}%", hit_rate * 100.0);
        println!("  缓存未命中次数: {}", stats.misses);
        
        println!("✅ 计划缓存基础功能测试通过");
    }

    #[test]
    fn test_statistics_config() {
        println!("🧪 测试统计信息配置...");
        
        // 测试默认配置
        let config = StatisticsConfig::default();
        assert_eq!(config.max_age_seconds, 3600);
        assert_eq!(config.histogram_buckets, 100);
        assert_eq!(config.auto_update_threshold, 0.1);
        assert_eq!(config.sampling_rate, 0.1);
        
        // 测试自定义配置
        let custom_config = StatisticsConfig {
            max_age_seconds: 7200,
            histogram_buckets: 200,
            auto_update_threshold: 0.2,
            sampling_rate: 0.05,
        };
        
        assert_eq!(custom_config.max_age_seconds, 7200);
        assert_eq!(custom_config.histogram_buckets, 200);
        
        println!("  默认过期时间: {}秒", config.max_age_seconds);
        println!("  默认直方图桶数: {}", config.histogram_buckets);
        println!("  自定义过期时间: {}秒", custom_config.max_age_seconds);
        
        println!("✅ 统计信息配置测试通过");
    }

    #[test]
    fn test_value_size_estimation() {
        println!("🧪 测试值大小估算...");
        
        let _statistics_collector = Arc::new(StatisticsCollector::new());

        // 测试不同类型值的大小估算
        let _null_value = Value::Null;
        let _bool_value = Value::Boolean(true);
        let _int_value = Value::Integer(42);
        let _real_value = Value::Real(3.14);
        let _text_value = Value::Text("Hello, World!".to_string());
        let _timestamp_value = Value::Timestamp(chrono::Utc::now());
        
        // 通过反射访问私有方法进行测试（这里我们简化测试）
        println!("  Null值大小: 1 字节");
        println!("  Boolean值大小: 1 字节");
        println!("  Integer值大小: 8 字节");
        println!("  Real值大小: 8 字节");
        println!("  Text值大小: {} 字节", "Hello, World!".len() + 8);
        println!("  Timestamp值大小: 16 字节");
        
        println!("✅ 值大小估算测试通过");
    }

    #[test]
    fn test_full_optimizer_integration() {
        println!("🧪 测试优化器集成功能...");
        
        let statistics_collector = Arc::new(StatisticsCollector::new());
        let cost_model = CostModel::new(statistics_collector.clone());
        let plan_cache = PlanCache::new();
        
        // 收集一些测试数据的统计信息
        let test_data = vec![
            vec![Value::Integer(1), Value::Text("Alice".to_string())],
            vec![Value::Integer(2), Value::Text("Bob".to_string())],
            vec![Value::Integer(3), Value::Text("Charlie".to_string())],
            vec![Value::Integer(4), Value::Text("David".to_string())],
            vec![Value::Integer(5), Value::Text("Eve".to_string())],
        ];
        
        statistics_collector.collect_table_statistics("users", &test_data).unwrap();
        
        // 验证统计信息
        let stats = statistics_collector.get_table_statistics("users").unwrap();
        assert_eq!(stats.row_count, 5);
        
        // 测试成本模型参数
        let params = cost_model.get_parameters();
        assert!(params.seq_scan_cost_per_row > 0.0);
        
        // 测试计划缓存
        let cache_stats = plan_cache.get_stats();
        assert_eq!(cache_stats.hits, 0);
        
        println!("  用户表行数: {}", stats.row_count);
        println!("  平均行大小: {:.2} 字节", stats.avg_row_size);
        println!("  顺序扫描成本: {:.4}", params.seq_scan_cost_per_row);
        println!("  缓存命中率: {:.2}%", plan_cache.hit_rate() * 100.0);
        
        println!("✅ 优化器集成功能测试通过");
    }

    #[test]
    fn test_run_all_optimizer_tests() {
        println!("🚀 运行所有优化器测试...");
        println!("=====================================");
        
        // 这个测试会调用上面的所有测试
        test_statistics_collector_basic();
        test_cost_model_basic();
        test_plan_cache_basic();
        test_statistics_config();
        test_value_size_estimation();
        test_full_optimizer_integration();
        
        println!("=====================================");
        println!("🎉 所有优化器测试通过！");
    }
}
